﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using System.Data.SqlClient;
using System.Data.Sql;
using System.Configuration;
using UricaoWeb.Datos.Excepciones.Empleado;

namespace UricaoWeb.Datos.ConexionBD.Empleados
{
    public class OperacionesBDEmpleado
    {
        /// <summary>
        /// Conexión a la base de datos
        /// </summary>
        OperacionesBD _bd;

        #region Variables Mensaje Excepciones
        private static string _mensajeSQLExcepcion = "No se pudo conectar a la base de datos del sistema";
        private static string _mensajeExcepcionGeneral = "Ha fallado general sistema en general";
        private static string _mensajeExcepcionNullObject = "Error, ha intentado acceder a un objeto vacio";

        private static string _mensajeExcepcionNoExiste = "No existe el procedimiento en la base de datos";
        private static string _mensajeExcepcionCasteo = "Falla en castear dato";
        private static string _mensajeExcepcionOperacionInvalida = "Operacion invalida";

        private static string _mensajeExcepcionParametroInvalido = "Parametro invalido";
        #endregion

        #region Métodos

        /// <summary>
        /// Constructor de la clase OperacionesBDEmpleado
        /// </summary>

        public OperacionesBDEmpleado()
        {
            _bd = new OperacionesBD();
        }

        /// <summary>
        /// Función que realiza la conexión a la base de datos y convierte el comando en un procedimiento de BD
        /// para poder ser accedido
        /// </summary>
        /// <param name="procedimientobd"> Nombre del procedimiento que se toma de la bd </param>
        /// <param name="conexion"> Conexion abierta </param>
        /// <returns>
        /// Returna el comando de establecimiento de conexión según 
        /// el stored procedure requerido
        /// Excepciones posibles:
        /// Excepciones ExcepcionesEmpleado - Tipo Exception
        /// </returns>
        private SqlCommand ConsultarProcedimientoBD(string procedimientobd, SqlConnection conexion)
        {
            try
            {
                SqlCommand operacion = new SqlCommand(procedimientobd, conexion);
                operacion.CommandType = CommandType.StoredProcedure;
                return operacion;
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007", _mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006", _mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
        }

        /// <summary>
        /// Método que actualiza en la base de datos la información deseada del empleado 
        /// Parámetros: 
        /// Empleado empleado: recibe el objeto de tipo Empleado
        /// Retorno: 
        /// bool true: si se actualizo correctamente, false: no se actualizo correctamente
        /// Excepciones posibles:
        /// Excepciones ExcepcionesEmpleado - Tipo: SqlException
        /// </summary>

        public bool ActualizarEmpleadoBD(Empleado empleado)
        {
            OperacionesBD operaciones = new OperacionesBD();

            string procedimiento = "actualizarEmpleado";
            SqlCommand comando = ConsultarProcedimientoBD(procedimiento, operaciones._cn);

            Dictionary<string, object> parametros = new Dictionary<string, object>();
            parametros.Add("@idEmpleado", empleado.IdEmpleado);
            parametros.Add("@nombreEmpleado", empleado.NombreEmpleado);
            parametros.Add("@apellidoEmpleado", empleado.ApellidoEmpleado);
            parametros.Add("@correoEmpleado", empleado.CorreoEmpleado);
            parametros.Add("@nacimientoEmpleado", empleado.FechaNacimientoEmpleado);
            parametros.Add("@direccionEmpleado", empleado.DireccionEmpleado);
            parametros.Add("@activoEmpleado", empleado.EstatusEmpleado);
            parametros.Add("@fkCargo", empleado.FkCargo);
            ParametrosConsulta(comando, parametros);
            comando.CommandType = CommandType.StoredProcedure;
            try
            {
                operaciones._cn.Open();
                comando.ExecuteNonQuery();
                operaciones._cn.Close();
                return true;
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001",_mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally
            {
                operaciones._cn.Close();
            }
        }

        /// <summary>
        /// Funcion que me retorna un empleado unico de la bd
        /// Parametro:
        /// SqlDataReader objetoBD: permite leer una secuencia de filas, resultado de la búsqueda
        /// Retorno:
        /// Object Empleado: Objeto Empleado con sus datos correspondientes
        /// Excepciones:
        /// Excepciones ExcepcionesEmpleado - Tipo: InvalidCastException
        /// Excepciones ExcepcionesEmpleado - Tipo: Exception
        /// </summary>
        /// 
        private Empleado EmpleadoUnicoBD(SqlDataReader objetoBD)
        {
            Empleado empleado = new Empleado();
            try
            {
                empleado.IdEmpleado = objetoBD.GetInt32(0);
                empleado.NombreEmpleado = objetoBD.GetString(1);
                empleado.ApellidoEmpleado = objetoBD.GetString(2);
                empleado.FechaNacimientoEmpleado = objetoBD.GetDateTime(3);
                empleado.DireccionEmpleado = objetoBD.GetString(4);
                empleado.EstatusEmpleado = objetoBD.GetBoolean(5);
                empleado.CorreoEmpleado = objetoBD.GetString(6);
                empleado.FkHotel = objetoBD.GetInt32(7);
                empleado.FkCargo = objetoBD.GetInt32(8);
                return empleado;
            }
            catch (InvalidCastException e)
            {
                throw new ExcepcionesEmpleado("0005", _mensajeExcepcionCasteo);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
        }

        /// <summary>
        /// Método que construye una lista de parámetros para añadisrlos a los procedimientos 
        /// Parámetros: 
        /// SqlCommand c: es un instrucción para ejecutar en la base de datos
        /// Dictionary<string, object> parametros: 
        /// </summary>

        private void ParametrosConsulta(SqlCommand c, Dictionary<string, object> parametros)
        {
            foreach (KeyValuePair<string, object> parametro in parametros)
            {
                c.Parameters.AddWithValue(parametro.Key, parametro.Value);
            }
        }

        /// <summary>
        /// Método que hace la conexión con la base de datos y llama al procedimiento
        /// que me retorna un empleado.
        /// Parametro:
        /// int idEmpleado: el id por el cual realizará la búsqueda
        /// int fkHotel: el hotel en el cual se realizará la busqueda del empleado
        /// Retorna:
        /// Empleado: Retorna un empleado
        /// Excepciones:
        /// Excepciones ExcepcionesEmpleado - Tipo: NullReferenceException
        /// Excepciones ExcepcionesEmpleado - Tipo: SqlException
        /// Excepciones ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public Empleado EmpleadoUnicoBD(int _idEmpleado, int _fkHotel)
        {
            OperacionesBD _operaciones = new OperacionesBD();
            string _procedimiento = "EmpleadoConsultarUnicoHotel";
            SqlCommand _comando = ConsultarProcedimientoBD(_procedimiento, _operaciones._cn);
            SqlDataReader _lectura;

            try
            {
                _operaciones._cn.Open();
                Dictionary<string, object> parametros = new Dictionary<string, object>();
                parametros.Add("@idEmpleado", _idEmpleado);
                parametros.Add("@fkHotel", _fkHotel);
                ParametrosConsulta(_comando, parametros);
                _lectura = _comando.ExecuteReader();
                while (_lectura.Read())
                {
                    Empleado empleado = EmpleadoUnicoBD(_lectura);
                    if (empleado != null)
                    {
                        return empleado;
                    }
                }
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally
            {
                _operaciones._cn.Close();
            }
            return null;
        }

        /// <summary>
        /// Metodo para consultar todos los empleados
        /// Parametro:
        /// int fkHotel: Hotel en el cual se realizará la búsqueda
        /// Retorna:
        /// List<Empleado>: Retorna lista de empleados
        /// Excepciones:
        /// Excepciones ExcepcionesEmpleado - Tipo: ArgumentException
        /// Excepciones ExcepcionesEmpleado - Tipo: InvalidOperationException
        /// Excepciones ExcepcionesEmpleado - Tipo: NullReferenceException
        /// Excepciones ExcepcionesEmpleado - Tipo: SqlException
        /// Excepciones ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public List<Empleado> ListaEmpleadoBD(int _fkHotel)
        {
            OperacionesBD _operaciones = new OperacionesBD();

            string _procedimiento = "EmpleadoConsultarHotel";

            SqlCommand _comando = ConsultarProcedimientoBD(_procedimiento, _operaciones._cn);
            SqlDataReader _lectura;
            List<Empleado> _listaEmpleados = new List<Empleado>();

            try
            {
                _operaciones._cn.Open();
                Dictionary<string, object> parametros = new Dictionary<string, object>();
                parametros.Add("@fkHotel", _fkHotel);
                ParametrosConsulta(_comando, parametros);
                _lectura = _comando.ExecuteReader();
                while (_lectura.Read())
                {
                    Empleado empleado = EmpleadoConsultar(_lectura);
                    if (empleado != null)
                    {
                        _listaEmpleados.Add(empleado);
                    }
                }
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007",_mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006",_mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally
            {
                _operaciones._cn.Close();
            }
            return _listaEmpleados;
        }

        /// <summary>
        /// Asignación del objeto de la BD a un objeto tipo Empleado
        /// según las posiciones de cada columna especificacda en la consulta
        /// Parametro:
        /// SqlDataReader _objetoBD: Objeto leído de la BD
        /// Retorna:
        /// Object Empleado: Retorna el objeto Empleado
        /// Excepciones:
        /// Excepciones ExcepcionesEmpleado - Tipo: InvalidCastException
        /// Excepciones ExcepcionesEmpleado - Tipo: Exception
        /// </summary>
        private Empleado EmpleadoConsultar(SqlDataReader objetoBD)
        {
            Empleado empleado = new Empleado();
            try
            {
                empleado.IdEmpleado = objetoBD.GetInt32(0);
                empleado.NombreEmpleado = objetoBD.GetString(1);
                empleado.ApellidoEmpleado = objetoBD.GetString(2);
            }
            catch (InvalidCastException e)
            {
                throw new ExcepcionesEmpleado("0005",_mensajeExcepcionCasteo);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002",_mensajeExcepcionGeneral);
            }
            return empleado;
        }

        /// <summary>
        /// Metodo para buscar empleados que coincidan con una busqueda en un campo de texto
        /// Parametro:
        /// string nombreApellido: Parametro de busqueda ya sea por nombre o apellido
        /// int fkHotel: indica el hotel en el cual se realizará la búsqueda
        /// Retorno:
        /// List<empleado>: Lista de empleados
        /// Excepciones:
        /// Excepciones ExcepcionesEmpleado - Tipo: ArgumentException
        /// Excepciones ExcepcionesEmpleado - Tipo: InvalidOperationException
        /// Excepciones ExcepcionesEmpleado - Tipo: NullReferenceException
        /// Excepciones ExcepcionesEmpleado - Tipo: SqlException
        /// Excepciones ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public List<Empleado> EmpleadoSearchBD(string _nombreApellido, int _fkHotel)
        {
            OperacionesBD _operaciones = new OperacionesBD();

            string _procedimiento = "EmpleadoConsultarSearchHotel";
            SqlCommand comando = ConsultarProcedimientoBD(_procedimiento, _operaciones._cn);
            SqlDataReader _lectura;
            List<Empleado> _listaEmpleado = new List<Empleado>();

            try
            {
                _operaciones._cn.Open();
                Dictionary<string, object> parametros = new Dictionary<string, object>();
                parametros.Add("@busqueda", _nombreApellido);
                parametros.Add("@fkHotel", _fkHotel);
                ParametrosConsulta(comando, parametros);
                _lectura = comando.ExecuteReader();

                while (_lectura.Read())
                {
                    Empleado empleado = EmpleadoConsultar(_lectura);
                    if (empleado != null)
                    {
                        _listaEmpleado.Add(empleado);
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007",_mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006",_mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0003",_mensajeExcepcionNullObject);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001",_mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002",_mensajeExcepcionGeneral);
            }
            finally
            {
                _operaciones._cn.Close();
            }
            return _listaEmpleado;
        }


        /// <summary>
        /// Método que me devuelve el id del último empleado insertado
        /// Retorno: 
        /// int idBd: Almacena el id del último empleado insertado
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: ArgumentException
        /// ExcepcionesEmpleado - Tipo: InvalidOperationException
        /// ExcepcionesEmpleado - Tipo: NullReferenceException
        /// ExcepcionesEmpleado - Tipo: SqlException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public int MaxId()
        {
            OperacionesBD operaciones = new OperacionesBD();

            string procedimiento = "MaxId";
            SqlCommand comando = ConsultarProcedimientoBD(procedimiento, operaciones._cn);
            SqlDataReader lectura;

            try
            {
                operaciones._cn.Open();
                lectura = comando.ExecuteReader();
                while (lectura.Read())
                {
                    int idBd = maxIdBD(lectura);
                    if (idBd != 0)
                    {
                        return idBd;
                    }
                }
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007",_mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006",_mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0003",_mensajeExcepcionNullObject);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001",_mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002",_mensajeExcepcionGeneral);
            }
            finally { operaciones._cn.Close(); }
            return 0;
        }

        /// <summary>
        /// Método que recibe lo obtenido de la consulta
        /// Parámetros: 
        /// SqlDataReader objetoBD: el dato obtenido de la base de datos
        /// Retorno: 
        /// int _idEmp: Se le asigna lo que arrojo la consulta
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: InvalidCastException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        private int maxIdBD(SqlDataReader objetoBD)
        {
            int idEmp = 0;
            try
            {
                idEmp = objetoBD.GetInt32(0);
            }
            catch (InvalidCastException e)
            {
                throw new ExcepcionesEmpleado("0005",_mensajeExcepcionCasteo);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0003", _mensajeExcepcionNullObject);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002",_mensajeExcepcionGeneral);
            }
            return idEmp;
        }

        /// <summary>
        /// Método que agrega el empleado en la base de datos
        /// Parámetros: 
        /// Objeto empleado: el objeto completo con todos los datos a insertar
        /// Retorno: 
        /// bool true: Si se inserto correctamento , false: No se inserto correctamente
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: SqlException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public bool AgregarEmpleado(Empleado empleado)
        {
            OperacionesBD operaciones = new OperacionesBD();

            string procedimiento = "AgregarEmpleado";
            SqlCommand comando = ConsultarProcedimientoBD(procedimiento, operaciones._cn);

            Dictionary<string, object> parametros = new Dictionary<string, object>();
            parametros.Add("@fkHotel", empleado.FkHotel);
            parametros.Add("@fkCargo", empleado.FkCargo);
            parametros.Add("@nombreEmpleado", empleado.NombreEmpleado);
            parametros.Add("@apellidoEmpleado", empleado.ApellidoEmpleado);
            parametros.Add("@correoEmpleado", empleado.CorreoEmpleado);
            parametros.Add("@nacimientoEmpleado", empleado.FechaNacimientoEmpleado);
            parametros.Add("@direccionEmpleado", empleado.DireccionEmpleado);
            parametros.Add("@activoEmpleado", empleado.EstatusEmpleado);

            ParametrosConsulta(comando, parametros);
            comando.CommandType = CommandType.StoredProcedure;
            try
            {
                operaciones._cn.Open();
                comando.ExecuteNonQuery();
                operaciones._cn.Close();
                return true;
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007", _mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006", _mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally
            {
                operaciones._cn.Close();
            }
        }

        /// <summary>
        /// Método que agrega un usuario en la base de datos
        /// Parámetros: 
        /// Objeto Usuario: el objeto completo con todos los datos a insertar
        /// Retorno: 
        /// bool true: Si se inserto correctamento , false: No se inserto correctamente
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: SqlException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public bool AgregarUsuario(Usuario usuario)
        {
            OperacionesBD operaciones = new OperacionesBD();

            string procedimiento = "AgregarUsuario";
            SqlCommand comando = ConsultarProcedimientoBD(procedimiento, operaciones._cn);

            Dictionary<string, object> parametros = new Dictionary<string, object>();
            parametros.Add("@fkEmpleado", usuario.FkEmpleado);
            parametros.Add("@nombreUsuario", usuario.NombreUsuario);
            parametros.Add("@claveUsuario", usuario.ClaveUsuario);

            ParametrosConsulta(comando, parametros);
            comando.CommandType = CommandType.StoredProcedure;
            try
            {
                operaciones._cn.Open();
                comando.ExecuteNonQuery();
                operaciones._cn.Close();
                return true;
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007", _mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006", _mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally
            {
                operaciones._cn.Close();
            }
        }

        /// <summary>
        /// Método que consulta si un correo ya existe y si le pertence al mismo empleado
        /// Parámetros: 
        /// String correo: correo empleado
        /// Int idEmpleado: id del empleado
        /// Retorno: 
        /// bool true: no existe el correo o es del mismo empleado
        /// bool false: si existe y no puedes agregarlo
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: SqlException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>


        public bool CorreoUnico(string correo, int idEmpleado)
        {
            OperacionesBD operaciones = new OperacionesBD();
            bool resultado = false;
            string procedimiento = "ConsultarCorreoExiste";
            SqlCommand comando = ConsultarProcedimientoBD(procedimiento, operaciones._cn);

            comando.Parameters.AddWithValue("@correoEmpleado", correo);
            comando.Parameters.AddWithValue("@idEmpleado", idEmpleado);
            comando.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue; ;

            comando.CommandType = System.Data.CommandType.StoredProcedure;
            try
            {
                operaciones._cn.Open();
                comando.ExecuteNonQuery();
                if ((int)comando.Parameters["@Return"].Value == 1)
                    resultado = true;
                else
                    resultado = false;
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007", _mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006", _mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally { operaciones._cn.Close(); }

            return resultado;
        }


        /// <summary>
        /// Método que consulta si un correo ya existe
        /// Parámetros: 
        /// String correo: correo empleado
        /// Retorno: 
        /// bool true: no existe el correo
        /// bool false: si existe y no puedes agregarlo
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: SqlException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>


        public bool CorreoUnico(string correo)
        {
            OperacionesBD operaciones = new OperacionesBD();
            bool resultado = false;
            string procedimiento = "ConsultarCorreoNuevo";
            SqlCommand comando = ConsultarProcedimientoBD(procedimiento, operaciones._cn);

            comando.Parameters.AddWithValue("@correoEmpleado", correo);
            comando.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue; ;

            comando.CommandType = System.Data.CommandType.StoredProcedure;
            try
            {
                operaciones._cn.Open();
                comando.ExecuteNonQuery();
                if ((int)comando.Parameters["@Return"].Value == 1)
                    resultado = true;
                else
                    resultado = false;
            }
            catch (ArgumentException e)
            {
                throw new ExcepcionesEmpleado("0007", _mensajeExcepcionParametroInvalido);
            }
            catch (InvalidOperationException e)
            {
                throw new ExcepcionesEmpleado("0006", _mensajeExcepcionOperacionInvalida);
            }
            catch (NullReferenceException e)
            {
                throw new ExcepcionesEmpleado("0004", _mensajeExcepcionNoExiste);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001", _mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002", _mensajeExcepcionGeneral);
            }
            finally { operaciones._cn.Close(); }

            return resultado;
        }

        /// <summary>
        /// Método que devuelte cuando empleados hay con el mismo nombre en la base de datos
        /// Parámetros: 
        /// string nombre: Nombre del empleado
        /// strinh apellido: Apellido del empleado
        /// Retorno: 
        /// int: Se le asigna lo que arroja la base de datos
        /// Excepciones posibles:
        /// ExcepcionesEmpleado - Tipo: SqlException
        /// ExcepcionesEmpleado - Tipo: Exception
        /// </summary>

        public int VerificarExistenciaNombreApellido(string _NombreEmpleado, string _ApellidoEmpleado)
        {
            OperacionesBD _bd = new OperacionesBD();

            try
            {
                SqlCommand _command = new SqlCommand("verificarExistenciaNombreApellido", _bd._cn);
                _command.CommandType = System.Data.CommandType.StoredProcedure;
                _command.Parameters.Add(new SqlParameter("@nombre_Empleado", SqlDbType.NVarChar, 50)).Value = _NombreEmpleado;
                _command.Parameters.Add(new SqlParameter("@apellido_Empleado", SqlDbType.NVarChar, 50)).Value = _ApellidoEmpleado;
                _command.Parameters.Add("@Return", SqlDbType.Int).Direction = ParameterDirection.ReturnValue;

                _bd._cn.Open();
                _command.ExecuteNonQuery();

                return (int)(_command.Parameters["@Return"].Value);
            }
            catch (SqlException e)
            {
                throw new ExcepcionesEmpleado("0001",_mensajeSQLExcepcion);
            }
            catch (Exception e)
            {
                throw new ExcepcionesEmpleado("0002",_mensajeExcepcionGeneral);
            }
            finally
            {
                _bd._cn.Close();
            }
        }

        #endregion
    }
}